Web resources such as web pages or streaming contents generally contain links to other data or resources, which themselves may contain links to other data. To fully load a web resource, all the linked and sub-linked data generally need to be retrieved. This incremental discovery may lead to a slow loading of the web resource, especially on high latency networks such as mobile networks.
Server push features are implemented in almost stateless servers that allow sending unsolicited data to receiving devices (or clients). Thus, when receiving a request for a given web resource, the server sends the requested resource and pushes linked data, hereafter called pushed data. Since data retrieved from a cache memory (called “cache” hereafter) located between the source (i.e. the server storing data) and the receiving device are known to be available mush more quickly than data retrieved from the server (network and server workload are reduced), the linked data are generally stored in the cache. The responsiveness of applications using such data is thus improved.
However, even if the load time of the web resource is reduced, the sending of pushed data occupies the bandwidth. In addition, some of the pushed data are already available to the receiving device, or not useful. Indeed, the server may push several times the same data. This implies an inadequate management of the bandwidth available for streaming the data.
Given that the server must handle thousands to millions of clients, storing the list of available data in the cache memory of all clients is not a realistic approach.
Moreover, some clients may remove some of these data depending on their own cache policy that may differ from a client to another. Indeed, each client chooses its own cache implementation. For instance, it may not cache any data, or on the contrary, it may cache all data that can be cached given the cache size. For example, Web client caches may vary from a few Megabytes to hundreds of Megabytes. Such Web clients generally use well-known eviction strategies such as LRU (for Least Recently Used) in order to release cache entries.
The variability of cache implementation (e.g. different eviction strategies, different cache size constraints) among clients makes it difficult for the source servers to precisely know which previously pushed data are still available in the cache memory of clients at the time of the request.